home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / raytrace / radiance / simplerd.lha / simplerad / FinalFTP / WalkT / walk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-22  |  13.5 KB  |  437 lines
  1. /**********************************************************************/
  2. /*                                                                    */
  3. /* walk.c : walk-through routines                                     */
  4. /*                                                                    */
  5. /* Copyright (C) 1992, Bernard Kwok                                   */
  6. /* All rights reserved.                                               */
  7. /* Revision 1.0                                                       */
  8. /* May, 1992                                                          *
  9. /**********************************************************************/
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <ctype.h>
  13. #include <fmclient.h>
  14. #include <math.h>
  15. #include <gl/gl.h>
  16. #include <gl/device.h>
  17. #include <sys/types.h>
  18. #include <dirent.h>
  19. #ifdef RELEASE3.2
  20. #include <malloc.h>
  21. #else
  22. #include <stdlib.h>
  23. #endif
  24.  
  25. #define IRIS4D 1
  26. #include "geo.h"
  27. #include "walk.h"
  28. #include "auto.h"
  29. #include "scene.h"
  30. #include "vcr.h"
  31.  
  32. /**********************************************************************/
  33. /* Prototypes                                                         */
  34. /**********************************************************************/
  35. void Initialize();
  36. void Orient();
  37. void HandleEvents();
  38. void DoEventsWind();
  39. void DoWind();
  40. void DoEventsPanel();
  41. void DoEventsHelp();
  42. void Draw_Scene();
  43. void Update_Scene();
  44. void initcylmat();
  45. void Draw_Axis();
  46. void InitMovement();
  47. void InitAbsMovement();
  48. void InitRelMovement();
  49.  
  50. extern void InitFonts();
  51. extern void InitGraphics(); 
  52. extern RelMovement *CreateRelMove();
  53. extern void ParseArgs();
  54. extern void Draw_Mesh();
  55. extern void Init_Scene();
  56. extern char HelpText[];
  57. extern SLogType ReadLog;
  58. extern long WindWid;
  59. extern Matrix viewmat;
  60.  
  61. /**********************************************************************/
  62. /* Main                                                               */
  63. /**********************************************************************/
  64. void main(argc, argv)
  65.      int argc;
  66.      char *argv[];
  67. {
  68.   System.UseVCR = FALSE;
  69.   System.VCRmode = FULL;
  70.   System.UseRGB = TRUE;
  71.   System.UseZBuf = TRUE;
  72.   System.UseDoubleBuf = TRUE;
  73.   System.gamma = FALSE;
  74.   System.FullScreen = FALSE;
  75.   Option.shadeBW = FALSE;
  76.   Option.RGBscale = 1.0;
  77.  
  78.   ParseArgs(argc, argv);
  79.   Initialize();
  80.   Draw_Scene();
  81.   HandleEvents();
  82. }
  83.  
  84. /**********************************************************************/
  85. /* Initialize graphics, queue, materials, fonts, lights               */
  86. /* and movement structures                                            */
  87. /**********************************************************************/
  88. void Initialize() 
  89. {
  90.   printf("Reading scene...\n");
  91.   Init_Scene();
  92.   printf("done\n");
  93.   InitGraphics();
  94.   InitFonts();
  95.   InitMovement();
  96.   InitHelp(HelpText);
  97.   InitQueue();
  98. }
  99.  
  100. /**********************************************************************/
  101. /* Initialize movement */
  102. /**********************************************************************/
  103. void InitMovement()
  104. {
  105.   /* Set initial Viewer position, and clear any movement */
  106.   InitAbsMovement(&Viewer);
  107.   InitRelMovement(&view);
  108.  
  109.   /* No movements recorded, and currently not moving */
  110.   Option.log = NOLOG;
  111.   Option.mode = STILL;
  112. }
  113.  
  114. /**********************************************************************/
  115. /* Clear relative view movement record, and object matrix */
  116. /**********************************************************************/
  117. void InitRelMovement(v)
  118.      RelMovement *v;
  119. {  
  120.   v->rot[0] = v->rot[1] = v->rot[2] = 0.0;
  121.   v->transl[0] = v->transl[1] = v->transl[2] = 0.0;
  122. }
  123.  
  124. /**********************************************************************/
  125. /* Clear absolute view movement record to default */
  126. /* based on size, position of environment */
  127. /**********************************************************************/
  128. void InitAbsMovement(c)
  129.      AbsMovement *c;
  130. {
  131.   long xsize, ysize;
  132.  
  133.   c->lookFrom.x = ReadLog.worldbox.max.x - 2.*ENLARGE_WORLD; 
  134.   c->lookFrom.y = ReadLog.worldbox.max.y - 2.*ENLARGE_WORLD; 
  135.   c->lookFrom.z = ReadLog.worldbox.max.z - 2.*ENLARGE_WORLD;
  136.   c->lookAt.x = (ReadLog.worldbox.max.x - ReadLog.worldbox.min.x ) / 2.0;
  137.   c->lookAt.y = (ReadLog.worldbox.max.y - ReadLog.worldbox.min.y ) / 2.0;
  138.   c->lookAt.z = (ReadLog.worldbox.max.z - ReadLog.worldbox.min.z ) / 2.0;
  139.   c->lookUp.x = 0.0; 
  140.   c->lookUp.y = 1.0; 
  141.   c->lookUp.z = 0.0;
  142.   c->fovx = 60;   c->fovy = 60;
  143.   c->near = 0.001; c->far = System.zfar;
  144.   getsize(&xsize, &ysize);
  145.   c->xRes = xsize; c->yRes = ysize;
  146.   c->bank = 0.0;
  147. }
  148.  
  149. /**********************************************************************/
  150. /* Set viewer's absolute position, get viewing matrix                 */
  151. /**********************************************************************/
  152. void SetViewerPos(viewer)
  153.      AbsMovement *viewer;
  154. {
  155.   winset(WindWid);
  156.   if (Option.debug) {
  157.     printf("\n\t> Camera set at:\n");
  158.     printf("\tfov=%d, aspect=%g, near=%g, far = %g\n",
  159.        viewer->fovx, System.scrnaspect, viewer->near, viewer->far);
  160.     printf("\tfrom=%g %g %g; at=%g %g %g; bank=%g\n\n",
  161.        viewer->lookFrom.x, viewer->lookFrom.y, viewer->lookFrom.z,
  162.      viewer->lookAt.x, viewer->lookAt.y, viewer->lookAt.z,     
  163.        viewer->bank);
  164.   }
  165.  
  166.   perspective(viewer->fovx*10, System.scrnaspect, viewer->near, viewer->far);
  167.   lookat(viewer->lookFrom.x, viewer->lookFrom.y, viewer->lookFrom.z,
  168.      viewer->lookAt.x, viewer->lookAt.y, viewer->lookAt.z,     
  169.      viewer->bank);
  170.   mmode(MVIEWING);
  171.   getmatrix(viewmat);
  172.   
  173.   if (Option.debug) printf("Set viewer position\n");
  174. }
  175.  
  176. /**********************************************************************/
  177. /* Update the scene viewed from current position                      */
  178. /* Note tranformations from viewer are "negated". To prevent too      */
  179. /* sudden movement, use of scaling factors ANGLE and COORD shock      */
  180. /* absorbers                                                          */
  181. /**********************************************************************/
  182. void Update_Scene() 
  183. {
  184.   int i;
  185.   Movement *amoves;                 /* Automated movement */
  186.   RelMovement *rmove;               /* Relative movment */
  187.   char mtype;                       /* Movement type (for automated) */
  188.  
  189.   if (Option.debug) printf("Updating scene. Mode = %d\n", Option.mode);
  190.   /* if (Option.mode != PREORIENT) */
  191.   InitRelMovement(&view);
  192.  
  193.   switch (Option.mode) {
  194.  
  195.   case ORIENT_SPIN: /* User is currently rotating viewer in y */    
  196.     view.rot[Y] = (view.m.x-view.om.x) * ANGLE_SHOCK_ABSORBER;
  197.     Orient();
  198.     if (Option.log) {
  199.       rmove = CreateRelMove(view.rot, view.transl);
  200.       LogRelMove(rmove, &Autoview, MOVEREL_SPIN);
  201.     }
  202.     view.om.x = view.m.x;
  203.     break;
  204.  
  205.   case ORIENT_ROT: /* User is currently rotating viewer in x,z */    
  206.     view.rot[X] = (view.m.x-view.om.x) * ANGLE_SHOCK_ABSORBER;
  207.     view.rot[Z] = (view.m.y-view.om.y) * ANGLE_SHOCK_ABSORBER;
  208.     Orient();
  209.     if (Option.log) {
  210.       rmove = CreateRelMove(view.rot, view.transl);
  211.       LogRelMove(rmove, &Autoview, MOVEREL_ROT);
  212.     }
  213.     view.om.x = view.m.x;
  214.     view.om.y = view.m.y;
  215.     break;
  216.  
  217.   case ORIENT_TRANSL: /* User is currently translating viewer */    
  218.     view.transl[X] = (view.m.x-view.om.x) * COORD_SHOCK_ABSORBER;
  219.     view.transl[Y] = (view.m.y-view.om.y) * COORD_SHOCK_ABSORBER;
  220.     Orient();
  221.     if (Option.log) {
  222.       rmove = CreateRelMove(view.rot, view.transl);
  223.       LogRelMove(rmove, &Autoview, MOVEREL_TRANSL);
  224.     }
  225.     view.om.x = view.m.x;
  226.     view.om.y = view.m.y;
  227.     break;
  228.  
  229.   case ORIENT_ZOOM:  /* User is currently zooming in */
  230.     view.transl[Z] = (view.om.x-view.m.x) * COORD_SHOCK_ABSORBER;
  231.     Orient();
  232.     if (Option.log) {
  233.       rmove = CreateRelMove(view.rot, view.transl);
  234.       LogRelMove(rmove, &Autoview, MOVEREL_ZOOM);
  235.     }
  236.     view.om.x = view.m.x;
  237.     break;
  238.  
  239.   case ORIENT_SCALE:  /* User is currently scaling objects wrt viewer */    
  240.     view.transl[Z] = (view.m.x-view.om.x);
  241.     Orient(); 
  242.     if (Option.log) {
  243.       rmove = CreateRelMove(view.rot, view.transl);
  244.       LogRelMove(rmove, &Autoview, MOVEREL_SCALE);
  245.     }
  246.     view.om.x = view.m.x;
  247.     break;
  248.  
  249.   case PREORIENT:              /* Orientation is being read from file */
  250.     amoves = Autoview;
  251.     for (i=0;i<moves_logged;i++) {
  252.       mtype = amoves->mtype;
  253.  
  254.       if (mtype == MOVEABS) {
  255.     loadmatrix(Identity);
  256.     CopyViewer(&Viewer,amoves->amove);   /* Change eye position */
  257.     Option.mode = ORIENT_ABS;
  258.  
  259.       } else if ((mtype == MOVEREL_ROT) ||
  260.          (mtype == MOVEREL_TRANSL) ||
  261.          (mtype == MOVEREL_ZOOM) ||
  262.          (mtype == MOVEREL_SCALE) ||
  263.          (mtype == MOVEREL_SPIN)) {
  264.     CopyViewChg(&view,amoves->rmove);      /* Change transformations */
  265.     if (mtype == MOVEREL_ROT) {
  266.       Option.mode = ORIENT_ROT; }
  267.     else if (mtype == MOVEREL_TRANSL) {
  268.       Option.mode = ORIENT_TRANSL; }
  269.     else if (mtype == MOVEREL_ZOOM) {
  270.       Option.mode = ORIENT_ZOOM; } 
  271.     else if (mtype == MOVEREL_SCALE) { 
  272.       Option.mode = ORIENT_SCALE; }
  273.     else if (mtype == MOVEREL_SPIN) { 
  274.       Option.mode = ORIENT_SPIN; 
  275.     }
  276.     
  277.       } else {
  278.     fprintf(stderr,"Update_Scene(): Invalid movement type: PREORIENT\n");
  279.     DoExit(-1);
  280.       }
  281.       Orient();                          /* (Re)orient */
  282.       Draw_Scene();                      /* (Re)draw scene */
  283.       amoves = amoves->next;
  284.     }
  285.     Option.mode = PREORIENT;
  286.     break;
  287.     
  288.   case STILL: /* Viewer is not moving */
  289.     if (Option.debug) printf("Something may be wrong. Not moving.");
  290.     break;
  291.  
  292.   default:
  293.     fprintf(stderr,"Update_Scene(): Invalid Movement Mode.\n");
  294.     DoExit(-1);
  295.     break;
  296.   }
  297.  
  298.   Draw_Scene();   /* (Re)draw scene */
  299. }
  300.  
  301. /**********************************************************************/
  302. /* Rotate in X, Z directions                                          */
  303. /**********************************************************************/
  304. void RotateXZ()
  305. {
  306.   if (Option.debug) printf("Rotating[%g,%g]\n", 
  307.                view.rot[X], view.rot[Z]);
  308.   rotate(view.rot[X], XDIR);
  309.   rotate(view.rot[Z], ZDIR);
  310. }
  311.  
  312. /**********************************************************************/
  313. /* Spin = Rotate in Y direction                                       */
  314. /**********************************************************************/
  315. void Spin()
  316. {
  317.   if (Option.debug) printf("Spinning[%g]\n", view.rot[Y]);
  318.   rotate(view.rot[Y], YDIR);
  319. }
  320.  
  321. /**********************************************************************/
  322. /* Translate in X or Y directions                                     */
  323. /**********************************************************************/
  324. void TranslateXY()
  325. {
  326.   translate(view.transl[X], view.transl[Y], 0.0);
  327.   if (Option.debug) printf("Translating[%f,%f]\n", 
  328.                view.transl[X], view.transl[Y]);
  329. }
  330.  
  331. /**********************************************************************/
  332. /* Zoom in by x factor = translation in Z                             */
  333. /**********************************************************************/
  334. void Zoom()
  335. {
  336.   translate(0.0, 0.0, view.transl[Z]);
  337.   if (Option.debug) printf("Zooming...%f\n", view.transl[Z]);
  338. }
  339.  
  340. /**********************************************************************/
  341. /* Uniformly scale the image                                          */
  342. /**********************************************************************/
  343. void Scale()
  344. {
  345.   double zfactor;
  346.   
  347.   zfactor = 1.0 + view.transl[Z] * 20.0 /* Option.ZoomFactor */ / 
  348.     (float) System.xscrnsize;
  349.   scale(zfactor, zfactor, zfactor);
  350.   if (Option.debug) printf("Scaling...%f\n", view.transl[Z]);
  351. }
  352.  
  353. /**********************************************************************/
  354. /* Update object transformation matrix based on viewing position, and */
  355. /* movement                                                           */
  356. /**********************************************************************/
  357. void Orient() 
  358. {
  359.   if (Option.debug) printf("Orienting with mode = %d\n", Option.mode);
  360.  
  361.   /* Change in camera position, set objmat to Identity */
  362.   if (Option.mode == ORIENT_ABS) { 
  363.     pushmatrix(); /* J3 */
  364.     loadmatrix(Identity);
  365.     getmatrix(objmat);
  366.     popmatrix(); /* J3 */
  367.   } 
  368.  
  369.   else { /* Find movement and set objmat */
  370.     pushmatrix();    
  371.     loadmatrix(Identity);
  372.     
  373.     switch(Option.mode) {
  374.     case ORIENT_ROT:          RotateXZ(); break;
  375.     case ORIENT_SPIN:         Spin(); break;
  376.     case ORIENT_TRANSL:       TranslateXY(); break;
  377.     case ORIENT_ZOOM:         Zoom(); break;
  378.     case ORIENT_SCALE:        Scale(); break;
  379.     default: break;
  380.     }
  381.     multmatrix(objmat); 
  382.     getmatrix(objmat);
  383.     popmatrix();
  384.   }
  385. }
  386.  
  387. /**********************************************************************/
  388. /* Redraw the scene */
  389. /**********************************************************************/
  390. void Draw_Scene() 
  391. {
  392.   /* Matrix tmp; */
  393.  
  394.   if (Option.debug) printf("Drawing Patches...\n");
  395.  
  396.   /* Set projection matrix, clear window and set shademodel */
  397.   pushmatrix(); {
  398.     SetViewerPos(&Viewer); 
  399.     czclear(0x000000, System.zfar);   
  400.     shademodel(Option.shademodel);
  401.   } popmatrix();   
  402.  
  403.   /* Set view/model matrix and draw objects */
  404.   pushmatrix(); {
  405.     loadmatrix(objmat);
  406.     multmatrix(viewmat);
  407.     Draw_Mesh();
  408.   } popmatrix(); 
  409.  
  410.   swapbuffers();
  411.  
  412.   /* if (System.UseVCR) vcr_grab(); */
  413. }
  414.  
  415.  
  416. /**********************************************************************/
  417. /* Draw x,y,z, axis */
  418. /**********************************************************************/
  419. /* XYZ axis */
  420. float origin[3] = {0,0,0};
  421. float xaxis[3] = {1,0,0};
  422. float yaxis[3] = {0,1,0};
  423. float zaxis[3] = {0,0,1};
  424.  
  425. void Draw_Axis()
  426. {
  427.   float c[4];
  428.  
  429.   c[0] = 1; c[1] = 0; c[2] = 0; c[3] = 0;
  430.   bgnline(); c4f(c); v3f(origin); v3f(xaxis); endline();
  431.   c[0] = 0; c[1] = 1; c[2] = 0; 
  432.   bgnline(); c4f(c); v3f(origin); v3f(yaxis); endline();
  433.   c[0] = 0; c[1] = 0; c[2] = 1; 
  434.   bgnline(); c4f(c); v3f(origin); v3f(zaxis); endline();
  435. }
  436.  
  437.